package com.cn.wanxi.util;


/**
 * 类描述
 */
public class Person {

    //描述人类的特征和行为
//    对于Java的属性和方法
//    名字（描述对象的特征） xiaoli（具体的特征）
//    身高 179
//    体重 55
//    性别  nan
    /**
     * 2021-5-31
     */
    /**
     * Java类的组成部分
     * 类由属性，方法，构造方法 ，内部类 ，代码块这5个部分组成(不对)
     * */
    /**
     * 包   -------------------------------------------------------------------------
     * 用于区分---归类
     * 包怎么做？ 创建包的时候需要注意些什么？
     * 1.包名创建
     *      1）包与包之间通过.隔开，其实就是创建文件夹，
     *      2）包名全部小写，包名只能包含一个意思
     *      3）包下面的类一般情况下会将名字和包名加上 PersionModel
     * 2.包的层次创建？
     *      1）一般情况下  com.cn.wanxi.bao
     *      2）com  国际
     *      3）cn   国内
     *      4)wanxi  公司名称
     *      5）bao  具体包内容
     * 3.第二阶段包有哪些？包的作用？
     *      1.servlet的三层架构
     *          1）页面控制层  和前端页面打交道 和页面一一对应
     *          2）服务逻辑层  着重于写逻辑代码（语法结构）
     *          3）数据实现层  存放数据或者将数据返回给服务逻辑层
     *      2.包有
     *          1）dao 数据实现层
     *          2）model 实体层
     *          3）service 服务逻辑层
     *          4）servlet  页面控制层
     *          5）util 工具层
     * */
    /**
     * 属性------------------------------------------------------------------------
     * 对象的特征
     * 需要Java对数据进行接收？存放数据的容器？（String name="liming"）；
     * Java的数据类型？ 定义数据？
     * 基本类型  （4）（8）需要了解基本类型的取值范围，默认值，字节数
     * 整型（4）  字节数 默认值 取值范围
     * byte        1        0     -128~127    -2^7~2^7-1                           byte age = 19;
     * short       2        0    -2^15~2^15-1    -32768（-2^15）
     * int          4       0   -2^31~2^31-1  -2,147,483,648
     * long         8       0       -2^63~2^63-1
     * 浮点型（2）
     * float        4       0.0
     * double       8       0.0
     * 字符型（1）
     * char          2        ' '
     * 布尔型（1）
     * boolean      1个bit位  false
     * 引用类型
     * 常见的引用类型？
     * 类，注解，接口，枚举
     * 强引用（Strong Reference）、
     * 软引用（Soft Reference）、
     * 弱引用（Weak Reference）、
     * 虚引用（Phantom Reference）4 种，这 4 种引用的强度依次减弱
     * 考察的是几个引用的生命周期和作用范围？
     * 明天简介：
     * 1.修饰符
     * 2.继承
     * 3.封装
     */
    /**
     * 一个完整的属性怎么定义？
     */
    /**
     * 2021-6-1
     */
    /**
     * 权限修饰符（访问修饰符） 特征修饰符（非访问修饰符） 数据类型  变量名 赋值运算符  字面量
     * 权限修饰符（访问修饰符） 主要目的保护当前对象是否可以被其他对象访问？
     * private
     * public
     * protected
     * 默认不写
     * 特征修饰符（非访问修饰符）
     * 数据类型
     * 变量名
     * 赋值运算符
     * 字面量
     * <p>
     * 继承？为什么要用继承？
     * 将所有公有的属性和方法放在父类
     * 所有的修饰符加protected
     * protected只能位子类调用
     * <p>
     * 如果需要创建对象时，
     * 所有的属性和方法应该默认位私有，
     * 如果需要别人调用，才去开放一个public
     * 这里等于时在进行封装---全是private
     * 一般情況下，我們不会把一个类写在另一个类里面，除非封装，不需要外部的其他类调用
     * 应该将所有类单独写在外面单独存在
     * <p>
     * <p>
     */
    /**
     * 非访问修饰符
     * 为了实现一些其他的功能，Java 也提供了许多非访问修饰符。
     * static 修饰符，用来修饰类方法和类变量。
     * final 修饰符，用来修饰类、方法和变量，final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
     * abstract 修饰符，用来创建抽象类和抽象方法。
     * synchronized 和 volatile 修饰符，主要用于线程的编程。
     * <p>
     * <p>
     */
    /**
     * static 修饰符
     * 静态变量： 修饰变量
     * static 关键字用来声明独立于对象的静态变量，
     * 无论一个类实例化多少对象，它的静态变量只有一份拷贝。
     * 静态变量也被称为类变量。局部变量不能被声明为 static 变量。
     * 以后如果想让一个变量只存在一次，直接用static  单例模式（只存在一次）
     * 静态方法：
     * <p>
     * static 关键字用来声明独立于对象的静态方法。
     * 静态方法不能使用类的非静态变量。
     * 静态方法从参数列表得到数据，然后计算这些数据。
     * 引用传递
     * -----------------------------
     */
    /**
     * java命名规范：
     * 包 全小写
     * 类 大驼峰  首字母大写  FindByUserNameAndPassWord
     * 属性、 小驼峰  findByUserNameAndPassWord
     * 方法  小驼峰findByUserNameAndPassWord
     * 变量   小驼峰findByUserNameAndPassWord
     * 常量  全大写 FIND_BY_USER_NAME_AND_PASS_WORD
     * <p>
     */
    /**
     * final 修饰符
     * final 变量：
     * final 表示"最后的、最终的"含义，变量一旦赋值后，不能被重新赋值。
     * 被 final 修饰的实例变量必须显式指定初始值。
     * <p>
     * final 修饰符通常和 static 修饰符一起使用来创建类常量。
     * final 类
     * final 类不能被继承，没有类能够继承 final 类的任何特性。
     *
     * final 方法
     * 父类中的 final 方法可以被子类继承，但是不能被子类重写。
     * 声明 final 方法的主要目的是防止该方法的内容被修改。
     *
     * final  类不能被继承          变量 常量                   方法 重写
     */
    /**
     * abstract
     * abstract 修饰符
     * 抽象类：
     * 抽象类不能用来实例化对象，声明抽象类的唯一目的是为了将来对该类进行扩充。
     * 一个类不能同时被 abstract 和 final 修饰。
     * 如果一个类包含抽象方法，那么该类一定要声明为抽象类，否则将出现编译错误。
     * 抽象类可以包含抽象方法和非抽象方法。
     * 抽象类是不是一定有抽象方法？
     * 抽象方法是不是一定在抽象类里面？
     * 接口？
     */
    /**
     * volatile 修饰符
     * volatile 修饰的成员变量在每次被线程访问时，
     * 都强制从共享内存中重新读取该成员变量的值
     * --------------
     * 缓存的目的？
     * 下一次访问直接取缓存数据？提高效率
     * 无痕浏览器？
     */
    /**
     * synchronized 同步锁 线程
     * synchronized 关键字声明的方法同一时间只能被一个线程访问。
     * synchronized 修饰符可以应用于四个访问修饰符。
     */
    /**
     * 一个完整的方法定义？
     * 权限修饰符 特征修饰符 返回值类型 方法名（参数）异常{
     * 执行体（方法体）
     * 返回值
     * }
     * void 表示没有返回值
     * throws Exception 异常什么意思？
     * 抛出异常，不处理 一直往上抛 --
     * 不要抛异常，哪里有异常，哪里捕获异常
     * try catch
     * 所有方法上的修飾都可以不要，比如返回值，那麽方法名必須和類名一致
     * 构造方法？--方法名和类名一样,可以有不同的参数
     * 说明每个类里面有一个默认的无参构造方法
     * 如果以及有一个有参的构造方法，则无参构造方法失效
     * 构造方法是否有返回值？构造方法返回值时对象本身
     *
     * 如果一个方法没有任何修饰，则较代码块{} 静态static{}区别？
     */
    /**
     * 2021-6-2
     */
    /**
     * 类的加载（执行）顺序？
     *public static final String NAME="aaa"; 会直接加载到常量池里面去
     * 当加载类的时候，首先执行的是类编译，编译类的时候首先执行静态代码快
     * 加载顺序---静态代码块--代码块--构造方法
     * 1.如果是继承，则先加载 父类  其他同上
     * 2.如果是在子类添加一个静态属性，
     * 先加载静态--从上往下执行--加载完成后在执行普通代码块
     */
    /**
     * 类于类之间的关系？
     * java 继承只能单继承可以多实现？
     * 泛化关系--- 继承  实现
     *  接口里面的变量为常量
     *  接口里面的方法默认为抽象方法
     *  接口里面可以有普通的方法，必须以default修饰
     *  接口是不是抽象类？ 接口是一个特殊抽象类
     *  只要有抽象方法，则当前类一定是抽象类
     *  抽象类是不是接口？不是
     *  接口里面的方法是不是都是抽象方法？不一定
     *  抽象类和接口的区别？
     *  Java 单继承多实现（多重继承）
     *  this和super的区别？
     *  super就近原则！
     *  值传递和引用传递？
     *  java 里面只有值传递 没有引用传递  平时所说的引用传递只是叫做传递的地址
     *  最简单的理解依赖关系？将一个对象当作参数进行传递时，他们之间的关系就是依赖
     *  泛化关系--- 继承  实现
     *  依赖
     *  关联  -聚合   组合
     */
    /**
     * 数组，集合？
     * 数据类型？
     * 集合 才是很多个数据类型的组合？
     * 什么是数组？ 相同类型的元素组合在一起
     * 所谓数组，是有序的元素序列。 若将有限个类型相同的变量的集合命名，那么这个名称为数组名。
     * {1，2，4}  {1，“3”，‘a’}
     * 数组的定义？
     * 静态定义：String 【】 name={"lili","lucy","coco"}；
     * 需要将所有的数组的值，直接放入大括号里面
     * 动态定义 String [] name=new String[8];
     * 只需要定义数组的长度
     * name[0]="lili";name[1]="lili";name[2]="lili";name[3]="lili";
     * name[4]=?
     * 默认值为null
     * 是一个有序的数组？
     * 取值时都是通过下标索引取拿值，下标从0开始
     * 数组的增删查改？
     * 数组是无法删除，无法新增，只能修改和查询。
     * 数组定义必须定义长度
     */
    /**
     * 集合？
     * 集合可以是不同的数据类型
     * 集合可以不用定义长度
     * 数组和集合的区别？
     * 数组查询速度比较快？
     * 集合新增删除比较快？
     *
     * 讲项目？
     */
    /**
     * object  类  所有引用类型的超类 （父类）
     * 方法
     * wait  线程等待
     * notyfy 线程唤醒
     * tostring 将对象转换为字符串
     * hashcode 得到hash码
     * getClass 得到当前对象 （反射）
     * finalize 垃圾回收
     * equal  比较
     * clone   深克隆  浅克隆  赋值一份
     * finalize和final和finally的区别？
     *
     */
    /**
     * 做项目
     * 第二阶段： 目的：将页面上所有用户需要修改的数据全部安装面向对象的方式提取到后台
     * servlet 最底層框架 ，所有Java的框架都是基于servlet来封装
     * jsp 渲染页面
     * servlet  里面有分层
     * 三层架构
     * servlet  页面控制层
     * service  服务逻辑层
     * dao       数据实现层
     * ---------------------
     * model    实体层
     * util     工具层
     * web       前端资源文件   --第一阶段资源文件
     * -------------------------
     * 1.创建项目
     * 2.创建jsp页面
     * 3.创建后台servlet层    和页面一一对应
     * 4.创建实体层
     * 5.创建数据层
     * 7.编写servlet层代码
     * 对于其他层  一个对象-----一个model--一个dao-一个service  相对应。
     * -------------------------------
     */
//    void Person() {//普通方法

//        System.out.println(name);
//        return "";
//    }
//
    {

    }

    static {

    }
    //    public static final String HOST = "www.baidu.com";
    //    static byte age;//赋值
//    static long leng;
//    static char aa;
//    private String privatename = "privateName";
//    protected String protectedename = "protectedName";
//    public String publicename = "publicName";
//    String name = "privateName";

    /**
     * java 程序入口
     *
     * @param args
     */
    public static void main(String[] args) {
//        String name = ChildServlet.NAME;//加载类，一定没有final，
//        System.out.println(name);
//        String aa="fasdfasdfa";
//        aa.charAt(2);
//        new ChildServlet();
//        Person person = new Person("");
//        new Person();
//        try {
//            int i = 10 / 0;
//        } catch (Exception e) {
//
//        }
//        System.out.println(11);
//        name="afsda";
//        byte age = 127;//赋值
//        age=111;
//Child child=new Child();
//child.
//Person person=new Person();
//person
//        1.当两个类之间相互调用，只有private私有的不能直接调用，拿不到值
//        2.如果在自己的类里面，可以直接调用所有的修饰符修饰的变量
//        3.如果在不同的包里面，则只能拿到公共public的变量
//        4.无论生命时候，私有的只能在当前类调用
//        5.如果不同包，继承，则拿不到默认不写
//        属性可以称为变量，但变量不能称为属性
//        必须是和方法同级别，必须是类的直接属性，直接变量
//        如果变量在方法里面，我们叫局部变量
//        静态变量
//        类变量
//        常量---变量
// 整型的默认值是什么？ 0   int
//  浮点型 默认值？0.0  double
//        System.out.println("------" + aa + "---------");
    }
    /**
     * 方法
     */
    /**
     * 构造方法
     */
    /**
     * 代码块
     */
    /*
     * 注释;(解释）帮助编程人员看懂
     * 注释的三种方式
     * 1.行注释
     * 2.方法注释
     * 3.块注释
     */

    /*
     * 测试案例
     * @param args
     */

}
